﻿#define _CRT_SECURE_NO_WARNINGS 1

//#include <iostream>
//
//using namespace std;

////由于引用折叠限定，f1实例化以后总是一个左值引用
//template<class T>
//void f1(T& x)
//{ }
//
////由于引用折叠限定，f2实例化以后可以是左值引用，也可以是右值引用
//template<class T>
//void f2(T&& x)
//{}
//
//int main()
//{
//	typedef int& lref;
//	using rref = int&&;
//	int n = 0;
//
//	//引用折叠规则
//	lref& r1 = n; // r1的类型是左值引用
//	lref&& r2 = n; // r2的类型是左值引用
//	rref& r3 = n; // r3的类型是 左值引用
//	rref&& r4 = 1; // r4的类型是右值引用
//
//	//没有折叠->实例化为void f1(int& x)
//	f1<int>(n);
//	f1<int>(0); // err
//
//	//折叠->实例化为void f1(int& x)
//	f1<int&>(n);
//	f1<int&>(0); // err
//
//	//折叠->实例化为void f1(int& x)
//	f1<int&&>(n);
//	f1<int&&>(0); // err
//
//	//折叠->实例化为void f1(const int& x)
//	f1<const int&>(n);
//	f1<const int&>(0);
//
//	//没有折叠->实例化为 void f2(int&& x)
//	f2<int>(n); // err
//	f2<int>(0);
//
//	//折叠->实例化为void f2(int& x)
//	f2<int&>(n);
//	f2<int&>(0);//err
//
//	//折叠->实例化为void f2(int&& x)
//	f2<int&&>(n); // err
//	f2<int&&>(0);
//
//	return 0;
//}

//template<class T>
//void Function(T&& t)
//{
//	int a = 0;
//	T x = a;
//	//x++;
//	cout << &a << endl;
//	cout << &x << endl << endl;
//}
//
//int main()
//{
//	//10是右值，自动推导出T为int
//	Function(10);//模版实例化为void Function(int&& t)
//
//	int a;
//	// a是左值，自动推导出T是int&
//	Function(a);//模版实例化为void Function(const int& t)
//
//	//move(a)是右值，自动推导T为int
//	Function(std::move(a)); //模版实例化为void Function(int&& t)
//
//	//b是左值，自动推导为const int&
//	const int b = 8;
//	Function(b);//模版实例化为void Function(const int& t)
//
//	//move(b)是右值，自动推导为const int
//	Function(std::move(b));//模版实例化为void Function(const int&& t)
//
//	return 0;
//}

//template < class _ty>
//_ty && forward(remove_reference_t<_ty>&_arg) noexcept
//{
//// forward an lvalue as either an lvalue or an rvaluereturn static_cast<_ty&&>(_arg);
//}
//
//void fun(int& x) { cout << "左值引用" << endl; }
//void fun(const int& x) { cout << "const 左值引用" << endl; }
//
//void fun(int&& x) { cout << "右值引用" << endl; }
//void fun(const int&& x) { cout << "const 右值引用" << endl; }
//
////万能引用
//template<class T>
//void function(T&& t)
//{
//	fun(forward<T>(t));
//}
//
//int main()
//{
//	// 10是右值，推导出t为int，模板实例化为void function(int&& t)
//	function(10); // 右值
//
//	int a;
//	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void function(int& t)
//	function(a); // 左值
//
//	// std::move(a)是右值，推导出T为int，模板实例化为void function(int&& t)
//	function(std::move(a)); // 右值
//
//	const int b = 8;
//	// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void function(const int&t)
//	function(b); // const 左值
//
//	// std::move(b)右值，推导出T为const int，模板实例化为void function(const int&&t)
//	function(std::move(b)); // const 右值
//
//	return 0;
//}


//int main()
//{
//	//auto add1 = [](int x, int y)->int {return x + y; };
//	//返回值可以省略，可以通过返回对象自动推导
//	auto add1 = [](int x, int y) {return x + y; };
//	cout << add1(1, 2) << endl;
//
//	//参数为空，可以省略
//	auto func1 = []
//	{
//		cout << "hello" << endl;
//		return 0;
//	};
//	func1();
//
//	int a = 0, b = 1;
//	auto swap1 = [](int& x, int& y)
//	{
//		int tmp = x;
//		x = y;
//		y = tmp;
//	};
//
//	swap(a, b);
//	cout << a << " " << b << endl;
//
//	return 0;
//}

//#include"List.h"
//
//int main()
//{
//	dyy::list<string> lt;
//	cout << "*************************" << endl;
//	string s1("111111111111111111111");
//	lt.push_back(s1);
//	cout << "*************************" << endl;
//	lt.push_back(string("22222222222222222222222222222"));
//	cout << "*************************" << endl;
//
//	lt.push_back("3333333333333333333333333333");
//	cout << "*************************" << endl;
//	lt.push_back(move(s1));
//	cout << "*************************" << endl;
//
//	return 0;
//}

//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//    //1.捕捉列表就算为空也不能省略
//    //2.参数为空，可以省略
//    //3.返回值可以省略，可以通过返回对象自动推导
//    auto func1 = []
//    {
//        cout << "hello" << endl;
//        return 0;
//    };
//    func1();
//
//    int a = 0, b = 1;
//    //1.有参数，参数列表不能省略
//    //2.没有返回值，返回值可以省略
//    auto swap1 = [](int& x, int& y)
//    {
//        int tmp = x;
//        x = y;
//        y = tmp;
//    };
//
//    swap1(a, b);
//    cout << a << " " << b << endl;
//
//    return 0;
//}

//#include <iostream>
//#include <vector>
//#include <algorithm>
//
//using namespace std;
//
//struct Goods
//{
//	string _name;
//	double _price;
//	int _evaluate;
//
//	//...
//
//	Goods(const char* str, double price, int evaluate)
//		:_name(str)
//		,_price(price)
//		,_evaluate(evaluate)
//	{ }
//};
//
////按价格升序排
//struct ComparePriceLess
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price < gr._price;
//	}
//};
//
////按价格降序排
//struct ComparePriceGreater
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price > gr._price;
//	}
//};
//
//int main()
//{
//	vector<Goods> v = { {"苹果", 2.1, 5}, {"香蕉", 3, 4}, {"橙子", 2.2, 3} , {"菠萝", 1.5, 4}};
//
//	//sort(v.begin(), v.end(), ComparePriceLess());
//	//sort(v.begin(), v.end(), ComparePriceGreater());
//
//	//按价格升序排
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
//	//按价格降序排
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; });
//
//	return 0;
//}


//#include <iostream>
//
//using namespace std;
//
////int x = 0;
//
//////捕捉列表必须为空
////auto func1 = []
////{
////    x++;
////};
//int x = 3;
//
//int main()
//{
//    int a = 0, b = 1, c = 2, d = 3;
//    
//    ////捕捉了两个变量a和b，a是值捕捉，b是引用捕捉
//    //auto func1 = [a, &b]
//    //{
//    //     //a++; // 值捕捉的变量是不能修改的
//    //     b++; // 引用捕捉的变量可以修改
//    //     int ret = a + b;
//    //     return ret;
//    //};
//    //cout << func1() << endl;
//
//    //隐式值捕捉
//    auto func2 = [=]
//    {
//        x++; // 全局变量默认可以用
//        //a++; // err，值捕捉，不能修改
//        int ret = x + a + b;
//        return ret;
//    };
//    cout << func2() << endl; // 5
//
//    //隐式引用捕捉
//    auto func3 = [&]
//    {
//        a++;
//        b++;
//        c++;
//    };
//    func3();
//    cout << a << " " << b << " " << c << " " << endl; // 1 2 3
//
//    return 0;
//}

//int main()
//{
//    int m = 1;
//
//    int a = 0, b = 1;
//    auto add1 = [](int x, int y)
//    {
//        m++; // err，没有对外部的m变量进行捕获，不能在lambda表达式中的函数体内部使用
//
//        return x + y;
//    };
//
//    cout << add1(a, b) << endl;
//
//    return 0;
//}


//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//    int a = 0, b = 1, c = 2, d = 3;
//
//    auto func7 = [=]()mutable
//    {
//        a++;
//        b++;
//        c++;
//        d++;
//        return a + b + c + d;
//    };
//    cout << func7() << endl; // 10
//    cout << a << " " << b << " " << c << " " << d << endl; // 0 1 2 3
//    
//    ////a,b变量值捕捉，其它变量引用捕捉
//    //auto func4 = [&, a, b]
//    //{
//    //    //a++;// err，
//    //    //b++; // err
//    //    c++;
//    //    d++;
//    //    return a + b + c + d;
//    //};
//    //func4();
//    //cout << a << " " << b << " " << c << " " << d << endl; // 0 1 3 4
//
//    ////a,b变量引用捕捉，其它变量值捕捉
//    //auto func5 = [=, &a, &b]
//    //{
//    //    a++;
//    //    b++;
//    //    //c++; // err
//    //    //d++; // err
//    //    return a + b + c + d;
//    //};
//    //func5();
//    //cout << a << " " << b << " " << c << " " << d << endl; // 1 2 3 4
//
//    return 0;
//}


#include <iostream>

using namespace std;

class Rate
{
	public :
	Rate(double rate)
		: _rate(rate)
	{
	}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	double rate = 0.49;
	// lambda
	auto r2 = [rate](double money, int year) {
		return money * rate * year;
		};
	// 函数对象
	Rate r1(rate);
	r1(10000, 2);
	r2(10000, 2);
	auto func1 = [] {
		cout << "hello world" << endl;
		}


